﻿#define _CRT_SECURE_NO_WARNINGS

//struct Date
//{
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	//初始化数组
//	int a[] = {1,2,3,4,5};
//	//初始化结构体
//	Date date = { 2024,10,29 };
//	return 0;
//}

//#include<iostream>
//#include<vector>
//using namespace std;
//
//struct Date
//{
//	Date(int year = 1, int month = 1, int day = 1)
//		:_year(year)
//		,_month(month)
//		,_day(day)
//	{
//		cout << "Date的构造" << endl;
//	}
//
//	Date(const Date& d)
//		:_year(d._year)
//		, _month(d._month)
//		, _day(d._day)
//	{
//		cout << "Date的拷贝构造" << endl;
//	}
//
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	//c++11可以不写=
//	int x{ 1 };
//
//	//这里的过程应该是用{ 2024,10,29 }构造一个临时对象 
//	//这个临时对象去拷贝构造d1
//	//但是编译器会直接把这个临时对象省略掉 直接构造d1这个对象
//	Date d1{ 2024,10,29 };
//
//	//下面这个例子就能证明出{}构造出来的是一个临时对象
//	// 如果不加const修饰那么编译时就会报错
//	// 这里报错的原因是以为{}构造出来的是一个临时对象 临时对象具有常性 导致了这里的参数类型不匹配的问题
//	//Date& d2 = { 2024,10,29 };
//
//	//这里就不会发生报错
//	//因为这里d2引用的是{}构造出来的临时对象 临时对象具有常性
//	const Date& d2 = { 2024,10,29 };
//
//	vector<Date> v;
//	v.push_back(d1);
//	v.push_back(Date{ 2024,10,29 });
//
//	//这里的编译器已经知道了v里存储的类型是Date
//	//所以传入多参数时 会直接用{}初始化出一个临时对象
//	v.push_back({ 2024,10,29 });
//
//	return 0;
//}

//#include<iostream>
//#include<string>
//using namespace std;



//int main()
//{
//	//以下都是左值
//	int a = 1;
//	const int b = 2;
//	int c = a + b;
//	string s("1111111");
//
//	//都能够正常的取地址
//	&a;&b;&c;&s;
//
//	//a+b的结果存在一个临时对象里 所以是右值
//	//&(a + b);
//
//	//10是字面值常量 是右值
//	//&10;
//
//	//匿名对象也是一个临时对象 也是右值
//	//cout<<&string("111111");
//	return 0;
//}


//#include<iostream>
//#include<string>
//using namespace std;
//
//int main()
//{
//	//
//	int a = 10;
//	const int b = 5;
//	string s("111111");
//	int* p = new int(0);
//	double x = 1.1, y = 2.2;
//
//	//下面都是正常的左值引用引用左值 给左值取别名
//	int& r1 = a;
//	const int& r2 = b;
//	string& r3 = s;
//	int*& r4 = p;
//	double& r5 = x;
//	double& r6 = y;
//
//	//右值引用给右值取别名
//	int&& rr1 = 10;
//	double&& rr2 = x + y;
//	string&& rr3 = string("11111");
//
//	//左值引用不能直接引用右值 但是用const修饰左值引用以后就可以引用右值了
//	const int& rx1 = 10;
//	const double& rx2 = x + y;
//	string rx3 = string("11111111");
//
//	//右值引用也不能直接引用左值 但是可以引用move以后的左值
//	int&& rrx1 = move(a);
//	const int&& rrx2 = move(b);
//	double&& rrx3 = move(x);
//	double&& rrx4 = move(y);
//
//	//右值引用本身的属性是左值
//	return 0;
//}


//#include<iostream>
//using namespace std;
//
//void f(int& x)
//{
//	cout << "f(int& x)" << endl;
//}
//
//void f(const int& x)
//{
//	cout << "f(const int& x)" << endl;
//}
//
//void f(int&& x)
//{
//	cout << "f(int&& x)" << endl;
//}
//
//int main()
//{
//	int a = 10;
//	const int b = 10;
//
//	f(a);	//调用f(int& x)
//	f(b);	//调用f(const int& x)
//	f(1);	//调用f(int&& x)
//
//	int&& x = 1;
//	//右值引用本身的属性是左值
//	f(x);	//调用f(int& x)
//	//move以后的左值属性就变成了右值
//	f(move(x));//调用f(int&& x)
//	return 0;
//}



//class Solution {
//public:
//	// 传值返回需要拷⻉
//	string addStrings(string num1, string num2) {
//		string str;
//		int end1 = num1.size() - 1, end2 = num2.size() - 1;
//		// 进位
//		int next = 0;
//		while (end1 >= 0 || end2 >= 0)
//		{
//			int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
//			int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
//			int ret = val1 + val2 + next;
//			next = ret / 10;
//			ret = ret % 10;
//			str += ('0' + ret);
//		}
//		if (next == 1)
//			str += '1';
//		reverse(str.begin(), str.end());
//		return str;
//	}
//};

#include<iostream>
#include<string>
using namespace std;

// 场景1
int main()
{
	bit::string ret = bit::addStrings("11111", "2222");
	cout << ret.c_str() << endl;
	return 0;
}
// 场景2
int main()
{
	bit::string ret;
	ret = bit::addStrings("11111", "2222");
	cout << ret.c_str() << endl;
	return 0;
}